﻿#define _CRT_SECURE_NO_WARNINGS 1
//#define 定义常量
//#include<stdio.h>
//
//#define MAX 100
//
//int main()
//{
//	int a = MAX;
//	printf("%d\n", a);
//
//	return 0;
//}

//#define定义宏
//定义一个宏，比较两个数之间的最大值是谁？
//#include<stdio.h>
//
//#define MAX_NUM(x, y) x > y ? x : y
//
//int main()
//{
//	int a = 10;
//	int b = 20;
//	printf("%d\n", MAX_NUM(a, b));
//
//	return 0;
//}

//#include<stdio.h>
//
////#define MAX_NUM(x, y) x > y ? x : y//这是一个有问题的示范
//#define MAX_NUM(x, y) ((x) > (y) ? (x) : (y))
//
//int main()
//{
//	int a = 10;
//	int b = 20;
//	printf("%d\n", 10*MAX_NUM(a, b));
//	//				10*x > y ? x : y
//	//这里就会有运算符优先级的问题，所以定义宏时尽量带多的括号避免出现优先级造成的各类问题
//
//	return 0;
//}

//带有副作⽤的宏参数
//#include<stdio.h>
//
//#define MAX_NUM(x, y) ((x) > (y) ? (x) : (y))
//
//int main()
//{
//	int a = 10;
//	int b = 12;
//	printf("%d\n", MAX_NUM(a++, b++));//这里的结果为13，同时a变量自增为11, b变量自增为14
//	//实际替换为了((a++) > (b++) ? (a++) : (b++))
//	//计算出结果的同时，会影响原来的a和b变量，这样的结果称为带有副作⽤的宏参数
//
//	return 0;
//}

//#运算符
////宏里被#修饰的参数会转换为字符串
//#include<stdio.h>
//
//#define PRINT(type, format) printf("Current value "#type" is "format"\n", type)
//
//int main()
//{
//	int a = 10;
//	float f = 3.14f;
//
//	//printf("Current value a is %d\n", a);
//	//printf("Current value f is %f\n", f);
//
//	//上面的代码如果要写多个类型的参数过于麻烦，而且函数也比较难实现这个效果，
//	// 现在就可以考虑用宏的方式实现这个效果比如：PRINT(f, "%f");
//	double d = 123.0;
//	PRINT(a, "%d");
//	PRINT(f, "%f");
//	PRINT(d, "%lf");
//
//
//	return 0;
//}

//##运算符
//将##两边的标识符合并为一个标识符
//实现一个功能，比较两个数之间的最大值是谁(两个参数的类型是相同的，但同时会有不同类型参与)

#include<stdio.h>

//用函数的方式写
//可以写但这样写的方式过于麻烦
//int Max_int(int x, int y)
//{
//	return x > y ? x : y;
//}
//
//float Max_float(float x, float y)
//{
//	return x > y ? x : y;
//}

//用宏的方式实现
//#define TYPE_MAX(type) \
//type type##_max(type x, type y) \
//{								\
//	return x > y ? x : y;		\
//}
//
//TYPE_MAX(int)   //int int_max(int x, int y)
//
//TYPE_MAX(float) //float float_max(float x, float y)
//
//TYPE_MAX(double)//double double_max(double x, double y)
//
//
//int main()
//{
//	int a = 10;
//	int b = 20;
//	printf("%d\n", int_max(a, b));
//
//	float f1 = 1.0f;
//	float f2 = 3.0f;
//	printf("%f\n", float_max(f1, f2));
//
//	double d1 = 10.0;
//	double d2 = 12.0;
//	printf("%lf\n", double_max(d1, d2));
//
//	return 0;
//}

//#undef
//用来移除一条宏定义
//#include<stdio.h>
//
//#define MAX 100
//
//int main()
//{
//	int a = 100;
//	printf("%d\n", a);
//	printf("%d\n", MAX);
//#undef MAX
//	//printf("%d\n", MAX);//无法使用
//#define MAX 110 //重新定义
//	printf("%d\n", MAX);
//
//	return 0;
//}

//条件编译
#include<stdio.h>

//1.#if 常量表达式 和#endif

//#define MAX 100
//
//int main()
//{
//#if MAX //MAX的值为真就参与编译, 为假就不参与编译
//	printf("hehe\n");
//#endif
//
//	return 0;
//}

//2. 多个分⽀的条件编译
//#define MAX 100
//
//int main()
//{
//#if MAX < 50
//	printf("hehe\n"); //小于50就参与编译
//#elif MAX >= 50 && MAX <= 80 
//	printf("haha\n");//大于等于50并且小于等于80就参与编译
//#else
//	printf("heihei\n");//大于80就参与编译
//#endif
//
//	return 0;
//}

//3.判断是否被定义
//#define MAX 100
//
//int main()
//{
////#ifdef MAX //判断MAX是否被定义，而不是判断MAX的值
////	printf("MAX已经定义了\n");
////#endif
//
//#ifndef MAX //判断MAX是否没有被定义, 没有定义后面的语句就参与编译, 定义了就不参与编译
//	printf("MAX没有被定义\n");
//#endif
//
//	return 0;
//}

//#include<stdio.h>
//
//int main()
//{
//	printf("hehe\n");//转置printf定义处可以看到stdio.h,里面有很多的嵌套#if #elif #else #endif
//
//	return 0;
//}

//头⽂件的包含
//#include<>//带<>的称为库文件的包含, 只会去标准的位置去找
//#include""//带""的称为本地文件(自定义文件)的包含, 会先到当前文件的目录去找，如果没找到则会去标准的位置去找
//所以如果是使用库的头文件时用#include<>, 用自定义的头文件时用#include""

